Lambda the Ultimate

Professor Susan L. Graham and the members of the Harmonia Research
Group at the University of California, Berkeley, announce the second
release of Harmonia-Mode, an XEmacs plug-in that provides
language-based services to the programmer while editing code. These
services include semantic search-and-replace, structural navigation,
structural undo, hypertext annotations, syntax highlighting and
auto-indentation. Harmonia's analyses are based on incremental lexing
(flex-based) and incremental parsing (GLR-based) technologies developed
by Graham and her graduate students.

This second release of Harmonia improves our previous support for Java,
C, Scheme and Cool (a language used in UC Berkeley's CS164 compiler
course), and adds support for Titanium (a high-performance parallel
dialect of Java created by the Titanium research group here at
Berkeley: http://www.cs.berkeley.edu/Research/Projects/titanium ).
Improvements to the Java language support include support for Java
1.4.2, an updated constant-propagation algorithm to better discover
compile-time constants, and general bug fixes. Harmonia runs on Solaris
9, Linux (Debian distribution and all other Linux distros), and new to
this release, MacOS X 10.3.

This release represents the second publicly available demonstration of
our project. Our next release will make the source code publicly
available to enable members of the community to build language-aware
programming tools with the Harmonia framework.

If you are interested in trying it out, please go to
http://harmonia.cs.berkeley.edu/harmonia/projects/harmonia-mode/doc/index.html
to see what it's all about.

Please report any feedback you have to the Harmonia group at
harmonia-bugs@sequoia.cs.berkeley.edu .

Thanks!

-- The Harmonia Research Group

Adrian Colyer, the lead of the AspectJ project, discusses the beauty of Lisp and SICP in his latest blog post.

So at the end of the day, this is the thing that really impresses me about Lisp (and about the approach to teaching programming taken in the book). The language is so simple, and yet constructed in such an elegant way that it just doesn't get in your way - whatever abstraction you need to build, Lisp lets you do it in a very direct manner. Java just feels plain clunky when you put it alongside :- lacking in power, ease of expression, and beauty.

Years ago, I once felt that there are some commonness between Chinese and Lisp. They both lack syntax, but expressing the same idea will need less words/time/space than other languages. What's more, they are both old languages but still used today.

Today, I just read an article (in Chinese) saying that "Thinking in Chinese is faster than that in English". The main argument is that Chinese has more voices than English. Chinese has 21 consonants, 35 vowels and 4 scales/tunes (音调, 四声 in Chinese but no counterpoint in English), so there can be totally 2900 voices, although only 1200 in use. English only has 20 consonants and 20 vowels, so there are only 400 voices at most (not to mention some unused voices). The time needed to think/pronounce one voice is relatively constant, which means that thinking in Chinese other than in English is somewhat like using a 64bit CPU other than a 32bit one. The author also mentions the example of 'pork,mutton,beef, and donkey meat' and the corresponding words in Chinese.

Since I have read several posters here about natual language, I post it here for more discussion.

The object-oriented modeling language Modelica is designed to allow convenient, component-oriented modeling of complex physical systems, e.g., systems containing mechanical, electrical, electronic, hydraulic, thermal, control, electric power or process-oriented subcomponents. The free Modelica language, free Modelica libraries and Modelica simulation tools are available, ready-to-use and have been utilized in demanding industrial applications, including hardware-in-the-loop simulations. The development and promotion of Modelica is organized by the non-profit Modelica Association.

I stumbled upon this site a couple of days ago. It look pretty interesting, the overview offers a good introduction to its features.

I figure this is the best place to squeeze my question in, so here goes.

A selector is either data constructor or a record field. In HM-style languages those are largely required to have unique names across entire program. Is there any way to lift this requirement and still have (partial) type inference? The hypothesis here is that unresolvable name clashes should be rare. When they do occur, the programmer should give an explicit type annotation.

Consider this:

data D1 = Foo Int | Bar Double
data D2 = Foo | Baz -- name clash, but not fatal yet

f1 (Foo x) = x
f1 (Bar y) = round y
f2 Foo = "Foo"
f2 Baz = "Baz" 
-- The inference algorithm should be able to figure out the type for f1 and f2
-- f1 :: D1 -> Int
-- f2 :: D2 -> [Char]

f3 (Foo x) = x
f3 _ = 42
f4 Foo = "Foo"
f4 _ = "Error"
-- Still should be possible to figure out types for f3 and f4, because 
-- Foo in D1 and Foo in D2 have different arities
-- f3 :: D1 -> Int
-- f4 :: D2 -> [Char]

f5 = Foo
-- ambiguity: Int->D1 or D2?
-- the compiler should signal an error

Is there an inference algorithm that does just that? If such questions are inappropriate for this forum, please feel free to delete my account and ban my IP :)

Not strictly language related, more language implementation related, but worth bringing to the attention of LtU. Quoting from the abstract to this paper:

The Memory Pool System (MPS) is a very general, adaptable, flexible, reliable, and efficient memory management system. It permits the flexible combination of memory management techniques, supporting manual and automatic memory management, in-line allocation, finalization, weakness, and multiple simultaneous co-operating incremental generational garbage collections. It also includes a library of memory pool classes implementing specialized memory management policies.

Between 1994 and 2001, Harlequin (now part of Global Graphics) invested about thirty person-years of effort developing the MPS. The system contained many innovative techniques and abstractions which were kept secret. In 1997 Richard Brooksby, the manager and chief architect of the project, and Nicholas Barnes, a senior developer, left Harlequin to form their own consultancy company, Ravenbrook, and in 2001, Ravenbrook acquired the MPS technology from Global Graphics. We are happy to announce that we are publishing the source code and documentation under an open source licence. This paper gives an overview of the system.

(emphases mine) Good news for language implementors! Richard Brooksby gave a talk on the system at last night's SchemeUK meeting, and it sounds like it has a few killer features that would make it worth considering over a roll-your-own solution or an embedding of, say, the Boehm-Demers-Weiser collector.

(One interesting nugget of information he mentioned was that during development of the MLWorks compiler and system, before they started development of the MPS, they measured the cost of object allocation at two-and-a-half instructions per allocation, on average - two instructions for the allocation, and half an instruction for the garbage collection overhead! I don't think MPS is quite that efficient, but it certainly has a lot of potential.)

Seeing an interest to linguistics in general, this might be not a complete off-topic for LtU:
Algebraic Semiotics

Semiotics is the study of signs. Our research attempts to make this area more systematic, rigorous, and applicable, as well as to do justice to its social and cognitive foundations. Algebraic semiotics combines aspects of algebraic specification and social semiotics. It has been applied to information visualization, user interface design, the representation of mathematical proofs, multimedia narrative, virtual worlds, and metaphor generation, among other things.

...if you are still not interested, how about this:

Mathematical foundations can be provided by the rather recent and very abstract field called "category theory" (it is not related to the area of psychology of the same name), by noting that sign systems together with semiotic morphisms form a category.

[on edit: oh no, I forgot to check previous art... :( Frank already linked to this page in the past...]

LLVM 1.4 is now out in the wild. This release adds a large number of new features including JIT support for PowerPC machines, improved debugging information with the C/C++ front-end, better optimizers, new archive support, and a new compiler driver.

Get it now!

-Chris

L is a "dynamically-typed, block-structured, purely-functional, strict language" which takes the following from Smalltalk:

* There is only one kind of value: the object.
* There is only one kind of operation: the message send.
* The grammar is small: few expression/parse types.
* The system is self-contained; everything is an object, including source code.
* The system is dynamic; objects, including source code, are editable at runtime.

adds the following:

# Modularity.
# Security.... A module should only have access to what it needs to do its job and no more.
# Thread Safety.
# Distributed Computing.
# Virtual Machine

found at E's what's new page

The design space of generic programming languages is largely unexplored, partly due to the time and effort required to implement such a language. In this paper we show how to write flexible prototype implementations of two existing generic programming languages, PolyP and Generic Haskell, using Template Haskell

The original template haskell paper showed how to wrtie printf and zipN, which are (or used to be) cited as dependent type examples -- what other haskell
extensions can we write without compiler hacking?